home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / MacMETH 3.2.1 / Sources / MacC2.6 / M2HM.DEF < prev    next >
Encoding:
Text File  |  1992-05-29  |  9.5 KB  |  123 lines  |  [TEXT/MEDT]
  1. DEFINITION MODULE M2HM; (* HS 19.4.85 / 10.6.86 / 28.4.89 / 30.5.90 *)
  2.  
  3.   (* Interface to the MOTOROLA MC68040 processor. *)
  4.  
  5.   FROM M2DM IMPORT ObjPtr, StrPtr, ConstValue, Standard;
  6.   FROM M2SM IMPORT Symbol;
  7.  
  8.   CONST   (* D-Register pool for expression evaluation *)
  9.           D0 = 0;  (* freely used, never reserved      *)
  10.           D1 = 1;  (* freely used, never reserved      *)
  11.  
  12.           (* F-Register pool for floating point arith. *)
  13.           F0 = 0;  (* freely used, never reserved      *)
  14.           cond: Condition; l: CARDINAL);    (* jump backward *)
  15.  
  16.   PROCEDURE StackTop(i: INTEGER);          (* increment stack pointer SP*)
  17.   PROCEDURE SetupSL(plev: CARDINAL);       (* push Static Link to stack *)
  18.   PROCEDURE CallSystem(n: CARDINAL);       (* call System.#n procedure  *)
  19.   PROCEDURE GenHalt(haltindex: CARDINAL);  (* call System.HALTX proc.   *)
  20.  
  21.   PROCEDURE LoadAdr   (VAR x: Item);       (* load address of x         *)
  22.   PROCEDURE LoadD     (VAR x: Item);       (* load data designated by x *)
  23.   PROCEDURE LoadP     (VAR x: Item);       (* load pointer design. by x *)
  24.   PROCEDURE LoadX     (VAR x: Item;        (* load and extend value(x)  *)
  25.                        req: WidType);      (* to requested width        *)
  26.   PROCEDURE LoadF     (VAR x: Item);       (* load data x to FP-Reg.    *)
  27.  
  28.   PROCEDURE Move      (VAR x, y: Item);    (* value(x) --> y            *)
  29.   PROCEDURE MoveAdr   (VAR x, y: Item);    (* adr(x)   --> y            *)
  30.   PROCEDURE MoveBlock (VAR x, y: Item;     (* mve 'sz' bytes of x to y  *)
  31.                        sz: INTEGER; isstring: BOOLEAN);
  32.   PROCEDURE FMove     (VAR x, y: Item);    (* floating move x --> y     *)
  33.  
  34.   PROCEDURE Neg1      (VAR x: Item);       (* x := -x                   *)
  35.   PROCEDURE Abs1      (VAR x: Item);       (* x := ABS(x)               *)
  36.   PROCEDURE Cap1      (VAR x: Item);       (* x := CAP(x)               *)
  37.   PROCEDURE Tst1      (VAR x: Item);       (* x - 0                     *)
  38.   PROCEDURE Com1      (VAR x: Item);       (* x := complement(x)        *)
  39.   PROCEDURE Inc1      (VAR x: Item);       (* x := x + 1                *)
  40.   PROCEDURE Dec1      (VAR x: Item);       (* x := x - 1                *)
  41.   PROCEDURE FMonad    (op: FMonadic;       (* monadic floating ops.     *)
  42.                        VAR x: Item);
  43.  
  44.   PROCEDURE Add2      (VAR x, y: Item);    (* x := x + y                *)
  45.   PROCEDURE Sub2      (VAR x, y: Item);    (* x := x - y                *)
  46.   PROCEDURE And2      (VAR x, y: Item);    (* x := x AND y              *)
  47.   PROCEDURE Or2       (VAR x, y: Item);    (* x := x OR y               *)
  48.   PROCEDURE Eor2      (VAR x, y: Item);    (* x := x EOR y              *)
  49.   PROCEDURE Div2      (VAR x, y: Item);    (* x := x DIV y              *)
  50.   PROCEDURE Mod2      (VAR x, y: Item);    (* x := x MOD y              *)
  51.   PROCEDURE Mul2      (VAR x, y: Item);    (* x := x * y                *)
  52.   PROCEDURE Cmp2      (VAR x, y: Item);    (* x - y                     *)
  53.   PROCEDURE In2       (VAR x, y: Item);    (* x IN y                    *)
  54.   PROCEDURE Shi2      (VAR x, y: Item;     (* x := x shifted by y       *)
  55.                        shiftop: ShiType);
  56.   PROCEDURE Ash2      (VAR x, y :Item;     (* x := x arith.shifted by y *)
  57.                        shiftop: ShiType);
  58.   PROCEDURE FDyad     (op: FDyadic;        (* dyadic floating ops.      *)
  59.                        VAR x, y: Item);
  60.  
  61.   PROCEDURE ConvertTyp(functyp: StrPtr; VAR x: Item);
  62.     (* x := x converted to type functyp *)
  63.  
  64.   PROCEDURE ConIndex(VAR x: Item; inc: INTEGER);
  65.     (* constant offset/index inc to base x *)
  66.  
  67.   PROCEDURE VarIndex(VAR x, y: Item; elsize: INTEGER);
  68.     (* variable offset/index y to base x (elements of size elsize) *)
  69.  
  70.   PROCEDURE GetHigh(VAR x: Item);
  71.     (* get high bound of dynamic array parameter x *)
  72.  
  73.   PROCEDURE Normalize(VAR x: Item; i: INTEGER);
  74.     (* normalize subrange x to zero by lowbound i *)
  75.  
  76.   PROCEDURE CheckHigh(VAR x, high: Item);
  77.     (* check x in the variable range [ 0 .. high ] *)
  78.  
  79.   PROCEDURE CheckClimit(VAR x: Item; limit: LONGINT);
  80.     (* check x in the constant interval [ 0 .. limit ] *)
  81.  
  82.   PROCEDURE CheckRange(VAR x: Item; min, max, BndAdr: INTEGER);
  83.     (* check x in the constant range [ min .. max ] *)
  84.  
  85.   PROCEDURE CheckPointer(VAR x: Item);
  86.     (* check x to be a non-NIL pointer *)
  87.  
  88.   PROCEDURE CheckDbltoSingle(VAR x, y: Item);
  89.     (* check for assignment of double-word x to single-word y *)
  90.  
  91.   PROCEDURE PreLoad(VAR op: Symbol; VAR x, y: Item);
  92.     (* preload x and/or y for dyadic operators *)
  93.  
  94.   PROCEDURE DynArray(VAR x, y: Item);
  95.     (* descriptor for dynamic array parameter *)
  96.  
  97.   PROCEDURE CopyDynArray(adr, size: INTEGER);
  98.     (* value for dynamic array parameter *)
  99.  
  100.   PROCEDURE EnterCase(VAR x: Item; base, lo, hi: INTEGER);
  101.     (* enter case-statement processor *)
  102.  
  103.   PROCEDURE ExitCase;
  104.     (* leave case-statement processor *)
  105.  
  106.   PROCEDURE Link(VAR l: CARDINAL; lev: CARDINAL);
  107.     (* generate entry-code for procedure at level lev *)
  108.  
  109.   PROCEDURE Unlink(parSize: INTEGER; lev: CARDINAL);
  110.     (* generate exit-code for procedure at level lev *)
  111.  
  112.   PROCEDURE CallInt(proc: ObjPtr);    (* call of local procedure     *)
  113.   PROCEDURE CallExt(proc: ObjPtr);    (* call of external procedure  *)
  114.   PROCEDURE CallInd(VAR x: Item);     (* call of procedure variable  *)
  115.  
  116.   PROCEDURE EnterModule;              (* main module's entry code    *)
  117.   PROCEDURE ExitModule;               (* main module's exit code     *)
  118.   PROCEDURE InitModule(m : CARDINAL); (* init of imported modules    *)
  119.  
  120.   PROCEDURE InitM2HM;
  121.  
  122. END M2HM. (* Copyright Departement Informatik, ETH Zuerich, Switzerland, 1992 *)
  123.